// pages/reduceTwo/reduceTwo.js
Page({

    data: {

    },

    onLoad: function (options) {

    },

    onShow: function () {
        var self = this;
        // self.test1();

        //----------------------------testReduce
        // self.testReduce();

        //----------------------------数组进行分类
        self.testGroup();
    },

    //需求:对一维数组进行分类,并转换成二维数组展示
    //进行分类展示,有相同的店名时,只展示一个店名,达到拆单显示效果
    test1() {
        let self = this;
        // return;
        let arr = [{
            code: "a店",
            name: "xiaohuai"
        },
        {
            code: "c店",
            name: "neiLuoBi"
        },
        {
            code: "a店",
            name: "hanGuo"
        },
        {
            code: "c店",
            name: "tnnyang"
        },
        {
            code: "b店",
            name: "nanFei"
        },
        {
            code: "a店",
            name: "yangMan"
        }
        ];
        let result = arr.reduce((result, item) => {
            let data = item
            // 思路:第一次先添加一个key,用于区分类别的元素,第二次添加判断对象是否存在这个key值,存在就归为一类
            result[item.code] ? result[item.code].push(data) : (result[item.code] = [data]);
            return result
        }, Object.create(null));
        console.log(result);//类似格式 { a:[{a:1,b:2},{a:1,c:3}] } 
        var newResult = [];//
        // 遍历对象,数组转变成二维数组 { a:[{a:1,b:2},{a:1,c:3}] } 转变成 [ [{a:1,b:2},{a:1,c:3}] ]
        for (var key in result) {
            // [{a:1,b:2},{a:1,c:3}] 作为一个整体添加到元素中
            let value = result[key];
            newResult.push(value);
        }
        // result = [result];
        console.log(newResult);
        self.setData({
            newResult: newResult
        })
    },


    testReduce() {
        //---计算一个对象数字中的最大值
        // var maxCallback = ( acc, cur ) => Math.max( acc.x, cur.x );
        var maxCallback = (acc, cur) => {
            // console.log(acc.x + '-' + cur.x);
            // console.log(acc + '-' + cur.x);
            //第一次acc=acc.x=2，运算结束后acc=22。第二次acc=22,此时acc.x=undefined;
            return Math.max(acc.x | acc, cur.x)
        };
        var result = [{ x: 2 }, { x: 22 }, { x: 222 }].reduce(maxCallback);
        console.log(result);   //222

        //---方案2：计算一个对象数字中的最大值
        // map/reduce; 这是更好的方案，即使传入空数组或更大数组也可正常执行
        var maxCallback2 = (max, cur) => Math.max(max, cur);
        var result = [{ x: 22 }, { x: 36 }, { x: 48 }].map(el => el.x).reduce(maxCallback2, -Infinity);
        console.log(result);   //48

        //---方案3：计算一个对象数字中的最小值,返回当前item条目
        // map/reduce; 这是更好的方案，即使传入空数组或更大数组也可正常执行
        var maxCallback2 = (max, cur) => Math.max(max, cur);
        var result = [{ x: 22 }, { x: 36 }, { x: 48 }].reduce((acc, cur) => (acc.x < cur.x) ? acc : cur, -Infinity);
        console.log(result);   //{x: 22}
    },

    //----------------------------数组进行分类，按code店铺进行分类
    testGroup() {
        let arr = [{
            code: "a店",
            name: "xiaohuai"
        },
        {
            code: "c店",
            name: "neiLuoBi"
        },
        {
            code: "c店",
            name: "tnnyang"
        },
        {
            code: "b店",
            name: "nanFei"
        },
        {
            code: "a店",
            name: "yangMan"
        }
        ];
        console.log(Object.create(null)); //{}
        var resultGroup = arr.reduce((acc, cur) => {
            acc[cur.code] = cur.code;
            return acc;
        }, Object.create(null));
        console.log(resultGroup);//{a店: "a店", c店: "c店", b店: "b店"}

        // 思路:第一次先添加一个key,用于区分类别的元素,第二次添加判断对象是否存在这个key值,存在就归为一类
        var resultGroup = arr.reduce((acc, cur) => {
            let data = cur;
            //判断cur.code是否已存在?  存在就添加到数组中 : 不存在就直接赋值
            acc[cur.code] ? acc[cur.code].push(data) : acc[cur.code] = [data];
            return acc;
        }, Object.create(null));
        console.log(resultGroup);//{a店: Array(2), c店: Array(2), b店: Array(1)}
    },

})